reakit-utils
Advanced tools
The reakit-utils package provides a collection of utility functions that are useful for building accessible and reusable React components. These utilities help with DOM manipulation, event handling, and other common tasks in React development.
DOM Utilities
DOM utilities help with common DOM manipulation tasks. For example, `isVisibleInViewport` checks if an element is visible within the viewport.
const element = document.getElementById('myElement');
const isVisible = isVisibleInViewport(element);Event Utilities
Event utilities simplify event handling. The `addEventListener` function, for instance, adds an event listener to a DOM element.
import { addEventListener } from 'reakit-utils';
const handleClick = () => console.log('Element clicked');
addEventListener(document.getElementById('myElement'), 'click', handleClick);Array Utilities
Array utilities provide functions for common array operations. `removeItemFromArray` removes a specified item from an array.
import { removeItemFromArray } from 'reakit-utils';
const array = [1, 2, 3, 4];
const newArray = removeItemFromArray(array, 3); // [1, 2, 4]String Utilities
String utilities offer functions for string manipulation. The `capitalize` function capitalizes the first letter of a string.
import { capitalize } from 'reakit-utils';
const text = 'hello world';
const capitalizedText = capitalize(text); // 'Hello world'Lodash is a popular utility library that provides a wide range of functions for common programming tasks, including array manipulation, object manipulation, and more. It is more comprehensive and widely used compared to reakit-utils.
Ramda is a functional programming library for JavaScript that provides utility functions for working with arrays, objects, and other data types. It emphasizes immutability and pure functions, making it a good choice for functional programming paradigms.
Date-fns is a utility library for working with dates in JavaScript. It provides a comprehensive set of functions for date manipulation and formatting. While it focuses specifically on dates, it offers more specialized functionality compared to reakit-utils.
This is experimental and may have breaking changes in minor versions.
npm:
npm i reakit-utils
Yarn:
yarn add reakit-utils
Receives a setState argument and calls it with currentValue if it's a
function. Otherwise return the argument as the new value.
argument React.SetStateAction<T>currentValue Timport { applyState } from "reakit-utils";
applyState((value) => value + 1, 1); // 2
applyState(2, 1); // 2
Ponyfill for Element.prototype.closest
import { closest } from "reakit-utils";
closest(document.getElementById("id"), "div");
// same as
document.getElementById("id").closest("div");
Similar to Element.prototype.contains.
Returns boolean
Creates an Event in a way that also works on IE 11.
element HTMLElementtype stringeventInit EventInit (optional, default {})import { createEvent } from "reakit-utils";
const el = document.getElementById("id");
el.dispatchEvent(createEvent(el, "blur", { bubbles: false }));
Returns Event
Creates a KeyboardEvent in a way that also works on IE 11.
element HTMLElementtype stringeventInit KeyboardEventInit (optional, default {})import { createKeyboardEvent } from "reakit-utils";
const el = document.getElementById("id");
el.dispatchEvent(createKeyboardEvent(el, "keydown", { key: "ArrowDown" }));
Returns KeyboardEvent
Returns an onKeyDown handler to be passed to a component.
options Options (optional, default {})
options.keyMapoptions.onKeyoptions.stopPropagationoptions.onKeyDownoptions.shouldKeyDown (optional, default ()=>true)options.preventDefault (optional, default true)Returns React.KeyboardEventHandler
Creates and dispatches Event in a way that also works on IE 11.
element HTMLElementtype stringeventInit EventInitimport { fireEvent } from "reakit-utils";
fireEvent(document.getElementById("id"), "blur", {
bubbles: true,
cancelable: true,
});
Creates and dispatches KeyboardEvent in a way that also works on IE 11.
element HTMLElementtype stringeventInit KeyboardEventInitimport { fireKeyboardEvent } from "reakit-utils";
fireKeyboardEvent(document.getElementById("id"), "keydown", {
key: "ArrowDown",
shiftKey: true,
});
Transforms an array with multiple levels into a flattened one.
array Array<T>import { flatten } from "reakit-utils";
flatten([0, 1, [2, [3, 4], 5], 6]);
// => [0, 1, 2, 3, 4, 5, 6]
Returns element.ownerDocument.activeElement.
Returns element.ownerDocument.defaultView || window.
element Element?Returns Window
Returns element.ownerDocument || window.document.
Returns Document
Cross-browser method that returns the next active element (the element that is receiving focus) after a blur event is dispatched. It receives the blur event object as the argument.
event (React.FocusEvent | FocusEvent)import { getNextActiveElementOnBlur } from "reakit-utils";
const element = document.getElementById("id");
element.addEventListener("blur", (event) => {
const nextActiveElement = getNextActiveElementOnBlur(event);
...
});
Checks if element has focus.
element Elementimport { hasFocusWithin } from "reakit-utils";
hasFocusWithin(document.getElementById("id"));
Returns boolean
Checks whether element is a native HTML button element or not.
element Elementimport { isButton } from "reakit-utils";
isButton(document.querySelector("button")); // true
isButton(document.querySelector("input[type='button']")); // true
isButton(document.querySelector("div")); // false
isButton(document.querySelector("input[type='text']")); // false
Returns boolean
Checks whether arg is empty or not.
arg anyimport { isEmpty } from "reakit-utils";
isEmpty([]); // true
isEmpty(["a"]); // false
isEmpty({}); // true
isEmpty({ a: "a" }); // false
isEmpty(); // true
isEmpty(null); // true
isEmpty(undefined); // true
isEmpty(""); // true
Returns boolean
Checks whether arg is an integer or not.
arg anyimport { isInteger } from "reakit-utils";
isInteger(1); // true
isInteger(1.5); // false
isInteger("1"); // true
isInteger("1.5"); // false
Returns boolean
Checks whether arg is an object or not.
arg anyReturns boolean
Checks whether arg is a plain object or not.
arg anyReturns boolean
Returns true if event has been fired within a React Portal element.
Returns boolean
Checks whether arg is a promise or not.
arg (T | Promise<T>)Returns boolean
Returns true if event.target and event.currentTarget are the same.
event React.SyntheticEventReturns boolean
Check whether the given element is a text field, where text field is defined by the ability to select within the input, or that it is contenteditable.
element HTMLElementReturns boolean
Ponyfill for Element.prototype.matches
Returns boolean
Omits specific keys from an object.
object Tpaths (ReadonlyArray<K> | Array<K>)import { omit } from "reakit-utils";
omit({ a: "a", b: "b" }, ["a"]); // { b: "b" }
Returns Omit<T, K>
Picks specific keys from an object.
object Tpaths (ReadonlyArray<K> | Array<K>)import { pick } from "reakit-utils";
pick({ a: "a", b: "b" }, ["a"]); // { a: "a" }
Immutably removes an index from an array.
array Aidx numberimport { removeIndexFromArray } from "reakit-utils";
removeIndexFromArray(["a", "b", "c"], 1); // ["a", "c"]
Returns Array A new array without the item in the passed index.
Immutably removes an item from an array.
array Aitem anyimport { removeItemFromArray } from "reakit-utils";
removeItemFromArray(["a", "b", "c"], "b"); // ["a", "c"]
// This only works by reference
const obj = {};
removeItemFromArray([obj], {}); // [obj]
removeItemFromArray([obj], obj); // []
Returns Array A new array without the passed item.
Compares two objects.
objA Record<any, any>?objB Record<any, any>?import { shallowEqual } from "reakit-utils";
shallowEqual({ a: "a" }, {}); // false
shallowEqual({ a: "a" }, { b: "b" }); // false
shallowEqual({ a: "a" }, { a: "a" }); // true
shallowEqual({ a: "a" }, { a: "a", b: "b" }); // false
Returns boolean
Splits an object (props) into a tuple where the first item is an object
with the passed keys, and the second item is an object with these keys
omitted.
props Tkeys (ReadonlyArray<K> | Array<K>)import { splitProps } from "reakit-utils";
splitProps({ a: "a", b: "b" }, ["a"]); // [{ a: "a" }, { b: "b" }]
Returns [any, Omit<T, K>]
Checks whether element is focusable or not.
element Elementimport { isFocusable } from "reakit-utils";
isFocusable(document.querySelector("input")); // true
isFocusable(document.querySelector("input[tabindex='-1']")); // true
isFocusable(document.querySelector("input[hidden]")); // false
isFocusable(document.querySelector("input:disabled")); // false
Returns boolean
Checks whether element is tabbable or not.
element Elementimport { isTabbable } from "reakit-utils";
isTabbable(document.querySelector("input")); // true
isTabbable(document.querySelector("input[tabindex='-1']")); // false
isTabbable(document.querySelector("input[hidden]")); // false
isTabbable(document.querySelector("input:disabled")); // false
Returns boolean
Returns all the focusable elements in container.
container ElementReturns the first focusable element in container.
container ElementReturns (Element | null)
Returns all the tabbable elements in container, including the container
itself.
container ElementfallbackToFocusable boolean? If true, it'll return focusable elements if there are no tabbable ones.Returns the first tabbable element in container, including the container
itself if it's tabbable.
container ElementfallbackToFocusable boolean? If true, it'll return the first focusable element if there are no tabbable ones.Returns (Element | null)
Returns the last tabbable element in container, including the container
itself if it's tabbable.
container ElementfallbackToFocusable boolean? If true, it'll return the last focusable element if there are no tabbable ones.Returns (Element | null)
Returns the next tabbable element in container.
container ElementfallbackToFocusable boolean? If true, it'll return the next focusable element if there are no tabbable ones.Returns (Element | null)
Returns the previous tabbable element in container.
container ElementfallbackToFocusable boolean? If true, it'll return the previous focusable element if there are no tabbable ones.Returns (Element | null)
Returns the closest focusable element.
element (T | null)?container ElementReturns (Element | null)
Ensures element will receive focus if it's not already.
element HTMLElement$1 EnsureFocusOptions (optional, default {})
$1.isActive (optional, default defaultIsActive)$1.preventScrollimport { ensureFocus } from "reakit-utils";
ensureFocus(document.activeElement); // does nothing
const element = document.querySelector("input");
ensureFocus(element); // focuses element
ensureFocus(element, { preventScroll: true }); // focuses element preventing scroll jump
function isActive(el) {
return el.dataset.active === "true";
}
ensureFocus(document.querySelector("[data-active='true']"), { isActive }); // does nothing
Returns number requestAnimationFrame call ID so it can be passed to cancelAnimationFrame if needed.
Transforms arg into an array if it's not already.
arg anyimport { toArray } from "reakit-utils";
toArray("a"); // ["a"]
toArray(["a"]); // ["a"]
Returns Array<any>
Render prop type
Type: function (props: P): React.ReactElement<any>
"as" prop
Type: React.ElementType<P>
Type: any
Returns only the HTML attributes inside P
type OnlyId = ExtractHTMLAttributes<{ id: string; foo: string }>;
type HTMLAttributes = ExtractHTMLAttributes<any>;
Type: Pick<HTMLAttributesWithRef, Extract<any, any>>
Transforms "a" | "b" into "a" & "b"
Type: any
Generic component props with "as" prop
Type: any
Returns the type of the items in an array
Type: any
Any function
Type: function (...args: Array<any>): any
React custom hook that combines multiple callbacks into one.
import React from "react";
import { useAllCallbacks } from "reakit-utils";
function Component(props) {
const onClick = () => {};
return (
<button onClick={useAllCallbacks(onClick, props.onClick)}>Button</button>
);
}
Returns AnyFunction
Merges up to two React Refs into a single memoized function React Ref so you can pass it to an element.
refA React.Ref<any>?refB React.Ref<any>?import React from "react";
import { useForkRef } from "reakit-utils";
const Component = React.forwardRef((props, ref) => {
const internalRef = React.useRef();
return <div {...props} ref={useForkRef(internalRef, ref)} />;
});
React.useLayoutEffect that fallbacks to React.useEffect on server side
rendering.
A React.Ref that keeps track of the passed value.
value TReturns React.MutableRefObject<T>
A React custom hook similar to useAllCallbacks, but
it'll pass the returned value from a function to the next function.
React custom hook that returns the very first value passed to initialState,
even if it changes between re-renders.
initialState SealedInitialState<T>A React.useEffect that will not run on the first render.
effect React.EffectCallbackdeps (ReadonlyArray<any> | undefined)?MIT © Diego Haz
FAQs
Reakit utils
We found that reakit-utils demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Node.js will be enforcing stricter semver-major PR policies a month before major releases to enhance stability and ensure reliable release candidates.
Security News
Research
Socket's threat research team has detected five malicious npm packages targeting Roblox developers, deploying malware to steal credentials and personal data.
Security News
vlt introduced its new package manager and a serverless registry this week, innovating in a space where npm has stagnated.